1.1. Field of the Invention
The present invention relates to the field of networked computer telecommunication, and in particular to a method and system for processing services associated with a contract between a service requester (SC) and a service provider (SP) wherein said services are to be provided via a network, wherein at least one service contract is defined between said service requester and said service provider.
1.2. Description and Disadvantages of Prior Art
Web services define a technique for describing software components to be accessed, methods for accessing these components, and discovery methods that enable the identification of relevant service providers. Web services are programming language-, programming model-, and system software neutral.
In this regard, two prior art Web services standards are relevant. They are shortly sketched out and commented as follows in order to introduce into the problems concerned in prior art:
First, the Simple Object Access Protocol (SOAP) provides a means of messaging between a service provider and a service requester. SOAP is independent of the underlying transport protocol, SOAP payloads can be carried on HTTP, FTP, JMS and other protocols.
FIG. 1 gives a SOAP example carried by the HTTP POST request.
HTTP messages consist of requests from client to server and responses from server to client. Both types of message (Request and Response messages) consist of a start-line, zero or more header fields (also known as “headers”), an empty line indicating the end of the header fields, and possibly a message-body.
The structure of a HTTP request message is depicted in FIG. 2: the first line of that message specifies the method to be applied to the resource, the identifier of the resource, and the HTTP protocol version in use. The HTTP protocol defines multiple request methods like GET, HEAD, POST, PUT, DELETE, TRACE, CONNECT, OPTIONS. The method indicates the operation to be performed on the resource.
The resource upon which to apply the request is identified by a Request-URI, which is a Uniform Resource Identifier. Uniform Resource Identifiers are simply formatted strings, which identify—via name, location, address or any other characteristic—a resource. For example: The well-known HTTP URL scheme used to locate network resources via the HTTP protocol contains resource-URIs. The scheme specific syntax and semantics for http URLs are
http_URL=“http:”“//”host[“:”port][request-uri]
If the port is empty or not given, port 80 is assumed. The semantics are that the identified resource is located at the server listening for TCP connections on that port of that host, and the Request-URI identifies the resource. The syntax and semantics for Request-URI are
Request-uri=abs_path[“?”query-string]
where the abs_path is an identifier of the resource and the query string is any kind of information which can be used for processing the request.
The header fields carry meta-information associated with the request or response.
The message-body of an HTTP message is used to carry the entity-body associated with the request or response. The message body depicted in FIG. 2 contains the actual SOAP message, which has a structure as given in FIG. 3: Inside An envelope section a number of header fields 1, . . .n are defined, which construct the so called SOAP header, which is followed by by the actual SOAP body, which comprises a second number of so called “Body fields 1 , . . .n.
Thus, the overall structure of a SOAP message carried over a network e.g. by a transport protocol like HTTP is depicted as a conglomeration of FIGS. 1 to 3 in FIG. 4.
FIG. 1 gives a SOAP example carried by the HTTP POST command. The HTTP request method is POST, the resource-URI is “/StockQuote”, which is an absolute path identifying the resource for which the request is intended. The resource-URI does not contain a query string.
Beside SOAP, there is in prior art the above-mentioned second relevant Web Service standard:
The Web Services Description Language (WSDL) is an XML document for describing Web Services as a set of endpoint operations on messages containing either document-oriented or Remote Procedure Call (RPC) payloads. So called service interfaces are defined abstractly in terms of message structures and sequences of simple message exchanges (or “operations” in WSDL terminology). They are then bound to a concrete network protocol and data-encoding format to define an endpoint. Related concrete endpoints are bundled to define abstract endpoints (services).
WSDL supports a service interface definition that is distinct from the protocol bindings used for service invocation. WSDL allows for multiple bindings for a single service. The service interface definition and the access binding are also distinct from the implementation of the functionality of the service. Service requestors usually generate client stub code for a web service from the corresponding WSDL; the WSDL of a service is usually requested from the service provider. The client stub code implements the necessary logic to create the correct message structure and the correct data encoding to address the endpoint. Since there is a distinction between definition, binding and implementation of a service, client stub codes created for a certain definition and binding can usually address various endpoints without requiring code changes, simply by using another endpoint address. FIG. 5A and the continuation thereof, FIG. 5B is given to disclose an exemplary WSDL document with further details to a person skilled in the art.
An important feature of Web Services is that they are stateless, according to a request-response scheme. A stateless server is one, which treats each request as an independent transaction, unrelated to any previous request. This simplifies the server design because it does not need to allocate storage to deal with conversations in progress or worry about freeing it if a client dies in mid-transaction. A disadvantage is that it may be necessary to include more information in each request and this extra-information will need to be interpreted by the server each time.
Having now described the constraints in which electronic communication of the above-mentioned kind runs, the disadvantages of prior art will be described next below:
Commercial usage of web services is based on a contract concluded between the service provider and the service requester. Such contract represents an agreement about the conditions for using and provisioning web services or web applications. The contract details may specify the conditions for billing the service, i.e. the price, service levels specifying the desired quality of service in a more detailed way, and further information which is highly critical for both the service requestor and the service provider. Basically, in prior art business, there are no limitations regarding the scope of a contract or the number of contracts: one contract may contain multiple services, or one service may be contained in multiple contracts, which are all valid at the same time.
In a typical prior art scenario, either two parties, ie, the Service Requester or Service Consumer, referred to herein as SC, and the Service Provider, referred to as SP, communicate, or three parties are comprised of the Web service Communication, i.e. the Service Requester, the Service provider who manages the above contracts and the Service Supplier, referred to as SS, which actually performs the service, which is sometimes hold invisible to the requester.
The only disclosure of such prior art, which is thus elaborated to address the above-mentioned web services facilities is published in “IBM Web Services Toolkit” (“Emerging Technologies Toolkit”), available in the year of 2002 for a trial period of 60 days based on IBM Alphaworks license agreements.
A short review on a software component as it is disclosed there, which is called “Contract Service” and comprises the most technical features relevant for the present invention is given, as follows:
The Contract Service handles the relationship between service providers and service requesters. It provides information about the type of contract between a service provider and the service hub (deployment contracts, also known as provider contracts) and between a service requestor and the service hub (usage contracts). Usage contracts can be used to subscribe to any combination of operations of any service provided through the service hub. A usage contract contains information such as how calls to service operations are to be charged for (by time, by number of uses, by amount of use etc.) and how much the subscribed service operations should cost for that client. For each usage contract the Contract Service defines the payment method and rating model to be used, the effective dates for that contract. Contracts may optionally store the digital signatures of both parties (service hub and service provider/requestor) to the contract. In the Utility Service demo that is shipped with the Web Services Toolkit, contracts are added to the Contract Service via a Utility Services Portal supplied with the demo, and a valid contract must be in place between a service hub and a service requestor before the requestor can use the service.
In this prior art contracting system for web services there are a number of disadvantages, introduced as follows:
Web services define a technique for describing software components the execution of which may have a considerable business value for a client, they describe how such web services are accessible by the clients and they describe discovery methods that enable the identification of relevant service providers to a client. Web services are mostly programming language-, programming model-, and system software neutral. Web services as described above are of high importance for the next future because they form a key part of dynamic e-business, and in particular of e-business on demand.
E-business on demand requires besides metering and accounting of services sophisticated systems to deal with the contractual relationships that have to be in place before actual on demand services can be offered to a client.
There is a remarkable similarity between e-business on demand and prior art software usage: in both fields a client is ready to pay some money in order to use a piece of software the execution of which serves him to get some predefined business value. As in prior art software usage different types of licenses are known and are useful to be customised to the specific needs of a customer it would be strongly desirable also to implement a licensing facility into such prior art contract management system, which performs the web services in favour to a client. The problem is that licensing may be considered as a special case, i.e. a special way of contracting for software usage. Disadvantageously the prior art contracting systems for performing web services do not offer any licensing until now. A specific difficulty for simply implementing existing licensing business methods into electronic web service management is that the user would need a high degree of personalisation in the licences, the vendor or provider of a web service cannot implement in program form all desired individual license types which are object of face-to-face negotiations between a service provider and a service requestor. Thus, the contract and license management basically falls into two categories:                a) high level contracting and        b) low level contracting.        
High level contracting deals with the above-mentioned face-to-face negotiations for agreeing on given contract conditions, while low level contracting deals with the runtime implementations of contract attributes as far as they are agreed on by both contracting parties. Personalised licenses between a service provider and a service requestor of web services require a great manual afford and are usually only set up with customers requiring enough licenses to be worth the afford of negotiation.
One of the disadvantageous limitations of the prior art contract management is that a one-to-one relationship exists between the consumer and the provider of a service offering exists. This represents a major problem to introduce this system to large scale environments, where for instance enterprises want to contract services for a number of consumers, for example a large number of employees using such services. If prior art contract management systems was enriched with existing software licensing know-how, the client could only choose from predefined licenses with a pre-set number of conditions, under which he can use the software or the service. If non of the offered licenses meets his requirements he will have to accept a license, which does not really fit his needs or, alternatively he cannot use the software or the service at all.
In many business situations the negotiations of different license policies, as it is basically desirable for a client, requires to much interaction in the sales process to be worth the effort for the service supplier. Further, it is also not possible to use well-known and established usage models as they are used in prior art software licensing, as prior art software licensing is coupled to offline processes for situations, in which the usage of a licensed software is done offline and independently from the software provider or the software seller.
1.3. Objectives of the Invention
It is thus an objective of the present invention to improve prior art methods of performing web services.